home *** CD-ROM | disk | FTP | other *** search
/ Cream of the Crop 1 / Cream of the Crop 1.iso / PROGRAM / CBASE102.ARJ / CBCMP.C < prev    next >
Text File  |  1991-09-23  |  12KB  |  613 lines
  1. /*    Copyright (c) 1989 Citadel    */
  2. /*       All Rights Reserved        */
  3.  
  4. /* #ident    "@(#)cbcmp.c    1.5 - 91/09/23" */
  5.  
  6. #include <ansi.h>
  7.  
  8. /* ansi headers */
  9. #include <ctype.h>
  10. #include <errno.h>
  11. #ifdef AC_STDDEF
  12. #include <stddef.h>
  13. #endif
  14. #ifdef AC_STRING
  15. #include <string.h>
  16. #endif
  17.  
  18. /* library headers */
  19. #include <blkio.h>
  20.  
  21. /* local headers */
  22. #include "cbase_.h"
  23.  
  24. /*man---------------------------------------------------------------------------
  25. NAME
  26.      cbcmp - cbase comparison functions
  27.  
  28. SYNOPSIS
  29.  
  30. DESCRIPTION
  31.  
  32. SEE ALSO
  33.      cbexp, cbimp.
  34.  
  35. ------------------------------------------------------------------------------*/
  36. #define vcmp(CMPFCT) {                            \
  37.     int i = 0;                            \
  38.     int c = 0;                            \
  39.     int elems = n / sizeof(*cp1);                    \
  40.                                     \
  41.     for (i = 0; i < elems; ++i) {                    \
  42.         c = CMPFCT(cp1, cp2, sizeof(*cp1));            \
  43.         if (c != 0) return c;                    \
  44.         ++cp1;                            \
  45.         ++cp2;                            \
  46.     }                                \
  47.     return 0;                            \
  48. }
  49.  
  50. /* charcmp:  t_char comparison function */
  51. #ifdef AC_PROTO
  52. static int charcmp(const void *p1, const void *p2, size_t n)
  53. #else
  54. static int charcmp(p1, p2, n)
  55. const void *p1;
  56. const void *p2;
  57. size_t n;
  58. #endif
  59. {
  60.     signed char n1 = '\0';
  61.     signed char n2 = '\0';
  62.  
  63.     memcpy(&n1, p1, sizeof(n1));
  64.     memcpy(&n2, p2, sizeof(n2));
  65.     if (n1 < n2) {
  66.         return -1;
  67.     } else if (n1 > n2) {
  68.         return 1;
  69.     }
  70.  
  71.     return 0;
  72. }
  73.  
  74. /* charvcmp:  t_charv comparison function */
  75. #ifdef AC_PROTO
  76. static int charvcmp(const void *p1, const void *p2, size_t n)
  77. #else
  78. static int charvcmp(p1, p2, n)
  79. const void *p1;
  80. const void *p2;
  81. size_t n;
  82. #endif
  83. {
  84.     signed char *cp1 = (signed char *)p1;
  85.     signed char *cp2 = (signed char *)p2;
  86.  
  87.     vcmp(charcmp);
  88. }
  89.  
  90. /* ucharcmp:  t_uchar comparison function */
  91. #ifdef AC_PROTO
  92. static int ucharcmp(const void *p1, const void *p2, size_t n)
  93. #else
  94. static int ucharcmp(p1, p2, n)
  95. const void *p1;
  96. const void *p2;
  97. size_t n;
  98. #endif
  99. {
  100.     unsigned char n1 = '\0';
  101.     unsigned char n2 = '\0';
  102.  
  103.     memcpy(&n1, p1, sizeof(n1));
  104.     memcpy(&n2, p2, sizeof(n2));
  105.     if (n1 < n2) {
  106.         return -1;
  107.     } else if (n1 > n2) {
  108.         return 1;
  109.     }
  110.  
  111.     return 0;
  112. }
  113.  
  114. /* ucharvcmp:  t_ucharv comparison function */
  115. #ifdef AC_PROTO
  116. static int ucharvcmp(const void *p1, const void *p2, size_t n)
  117. #else
  118. static int ucharvcmp(p1, p2, n)
  119. const void *p1;
  120. const void *p2;
  121. size_t n;
  122. #endif
  123. {
  124.     unsigned char *cp1 = (unsigned char *)p1;
  125.     unsigned char *cp2 = (unsigned char *)p2;
  126.  
  127.     vcmp(ucharcmp);
  128. }
  129.  
  130. /* shortcmp:  t_short comparison function */
  131. #ifdef AC_PROTO
  132. static int shortcmp(const void *p1, const void *p2, size_t n)
  133. #else
  134. static int shortcmp(p1, p2, n)
  135. const void *p1;
  136. const void *p2;
  137. size_t n;
  138. #endif
  139. {
  140.     signed short n1 = 0;
  141.     signed short n2 = 0;
  142.  
  143.     memcpy(&n1, p1, sizeof(n1));
  144.     memcpy(&n2, p2, sizeof(n2));
  145.     if (n1 < n2) {
  146.         return -1;
  147.     } else if (n1 > n2) {
  148.         return 1;
  149.     }
  150.  
  151.     return 0;
  152. }
  153.  
  154. /* shortvcmp:  t_shortv comparison function */
  155. #ifdef AC_PROTO
  156. static int shortvcmp(const void *p1, const void *p2, size_t n)
  157. #else
  158. static int shortvcmp(p1, p2, n)
  159. const void *p1;
  160. const void *p2;
  161. size_t n;
  162. #endif
  163. {
  164.     signed short *cp1 = (signed short *)p1;
  165.     signed short *cp2 = (signed short *)p2;
  166.  
  167.     vcmp(shortcmp);
  168. }
  169.  
  170. /* ushortcmp:  t_ushort comparison function */
  171. #ifdef AC_PROTO
  172. static int ushortcmp(const void *p1, const void *p2, size_t n)
  173. #else
  174. static int ushortcmp(p1, p2, n)
  175. const void *p1;
  176. const void *p2;
  177. size_t n;
  178. #endif
  179. {
  180.     unsigned short n1 = 0;
  181.     unsigned short n2 = 0;
  182.  
  183.     memcpy(&n1, p1, sizeof(n1));
  184.     memcpy(&n2, p2, sizeof(n2));
  185.     if (n1 < n2) {
  186.         return -1;
  187.     } else if (n1 > n2) {
  188.         return 1;
  189.     }
  190.  
  191.     return 0;
  192. }
  193.  
  194. /* ushortvcmp:  t_ushortv comparison function */
  195. #ifdef AC_PROTO
  196. static int ushortvcmp(const void *p1, const void *p2, size_t n)
  197. #else
  198. static int ushortvcmp(p1, p2, n)
  199. const void *p1;
  200. const void *p2;
  201. size_t n;
  202. #endif
  203. {
  204.     unsigned short *cp1 = (unsigned short *)p1;
  205.     unsigned short *cp2 = (unsigned short *)p2;
  206.  
  207.     vcmp(ushortcmp);
  208. }
  209.  
  210. /* intcmp:  t_int comparison function */
  211. #ifdef AC_PROTO
  212. static int intcmp(const void *p1, const void *p2, size_t n)
  213. #else
  214. static int intcmp(p1, p2, n)
  215. const void *p1;
  216. const void *p2;
  217. size_t n;
  218. #endif
  219. {
  220.     signed int n1 = 0;
  221.     signed int n2 = 0;
  222.  
  223.     memcpy(&n1, p1, sizeof(n1));
  224.     memcpy(&n2, p2, sizeof(n2));
  225.     if (n1 < n2) {
  226.         return -1;
  227.     } else if (n1 > n2) {
  228.         return 1;
  229.     }
  230.  
  231.     return 0;
  232. }
  233.  
  234. /* intvcmp:  t_intv comparison function */
  235. #ifdef AC_PROTO
  236. static int intvcmp(const void *p1, const void *p2, size_t n)
  237. #else
  238. static int intvcmp(p1, p2, n)
  239. const void *p1;
  240. const void *p2;
  241. size_t n;
  242. #endif
  243. {
  244.     signed int *cp1 = (signed int *)p1;
  245.     signed int *cp2 = (signed int *)p2;
  246.  
  247.     vcmp(intcmp);
  248. }
  249.  
  250. /* uintcmp:  t_uint comparison function */
  251. #ifdef AC_PROTO
  252. static int uintcmp(const void *p1, const void *p2, size_t n)
  253. #else
  254. static int uintcmp(p1, p2, n)
  255. const void *p1;
  256. const void *p2;
  257. size_t n;
  258. #endif
  259. {
  260.     unsigned int n1 = 0;
  261.     unsigned int n2 = 0;
  262.  
  263.     memcpy(&n1, p1, sizeof(n1));
  264.     memcpy(&n2, p2, sizeof(n2));
  265.     if (n1 < n2) {
  266.         return -1;
  267.     } else if (n1 > n2) {
  268.         return 1;
  269.     }
  270.  
  271.     return 0;
  272. }
  273.  
  274. /* uintvcmp:  t_uintv comparison function */
  275. #ifdef AC_PROTO
  276. static int uintvcmp(const void *p1, const void *p2, size_t n)
  277. #else
  278. static int uintvcmp(p1, p2, n)
  279. const void *p1;
  280. const void *p2;
  281. size_t n;
  282. #endif
  283. {
  284.     unsigned int *cp1 = (unsigned int *)p1;
  285.     unsigned int *cp2 = (unsigned int *)p2;
  286.  
  287.     vcmp(uintcmp);
  288. }
  289.  
  290. /* longcmp:  t_long comparison function */
  291. #ifdef AC_PROTO
  292. static int longcmp(const void *p1, const void *p2, size_t n)
  293. #else
  294. static int longcmp(p1, p2, n)
  295. const void *p1;
  296. const void *p2;
  297. size_t n;
  298. #endif
  299. {
  300.     signed long n1 = 0;
  301.     signed long n2 = 0;
  302.  
  303.     memcpy(&n1, p1, sizeof(n1));
  304.     memcpy(&n2, p2, sizeof(n2));
  305.     if (n1 < n2) {
  306.         return -1;
  307.     } else if (n1 > n2) {
  308.         return 1;
  309.     }
  310.  
  311.     return 0;
  312. }
  313.  
  314. /* longvcmp:  t_longv comparison function */
  315. #ifdef AC_PROTO
  316. static int longvcmp(const void *p1, const void *p2, size_t n)
  317. #else
  318. static int longvcmp(p1, p2, n)
  319. const void *p1;
  320. const void *p2;
  321. size_t n;
  322. #endif
  323. {
  324.     signed long *cp1 = (signed long *)p1;
  325.     signed long *cp2 = (signed long *)p2;
  326.  
  327.     vcmp(longcmp);
  328. }
  329.  
  330. /* ulongcmp:  t_ulong comparison function */
  331. #ifdef AC_PROTO
  332. static int ulongcmp(const void *p1, const void *p2, size_t n)
  333. #else
  334. static int ulongcmp(p1, p2, n)
  335. const void *p1;
  336. const void *p2;
  337. size_t n;
  338. #endif
  339. {
  340.     unsigned long n1 = 0;
  341.     unsigned long n2 = 0;
  342.  
  343.     memcpy(&n1, p1, sizeof(n1));
  344.     memcpy(&n2, p2, sizeof(n2));
  345.     if (n1 < n2) {
  346.         return -1;
  347.     } else if (n1 > n2) {
  348.         return 1;
  349.     }
  350.  
  351.     return 0;
  352. }
  353.  
  354. /* ulongvcmp:  t_ulongv comparison function */
  355. #ifdef AC_PROTO
  356. static int ulongvcmp(const void *p1, const void *p2, size_t n)
  357. #else
  358. static int ulongvcmp(p1, p2, n)
  359. const void *p1;
  360. const void *p2;
  361. size_t n;
  362. #endif
  363. {
  364.     unsigned long *cp1 = (unsigned long *)p1;
  365.     unsigned long *cp2 = (unsigned long *)p2;
  366.  
  367.     vcmp(ulongcmp);
  368. }
  369.  
  370. /* floatcmp:  t_float comparison function */
  371. #ifdef AC_PROTO
  372. static int floatcmp(const void *p1, const void *p2, size_t n)
  373. #else
  374. static int floatcmp(p1, p2, n)
  375. const void *p1;
  376. const void *p2;
  377. size_t n;
  378. #endif
  379. {
  380.     float n1 = 0;
  381.     float n2 = 0;
  382.  
  383.     memcpy(&n1, p1, sizeof(n1));
  384.     memcpy(&n2, p2, sizeof(n2));
  385.     if (n1 < n2) {
  386.         return -1;
  387.     } else if (n1 > n2) {
  388.         return 1;
  389.     }
  390.  
  391.     return 0;
  392. }
  393.  
  394. /* floatvcmp:  t_floatv comparison function */
  395. #ifdef AC_PROTO
  396. static int floatvcmp(const void *p1, const void *p2, size_t n)
  397. #else
  398. static int floatvcmp(p1, p2, n)
  399. const void *p1;
  400. const void *p2;
  401. size_t n;
  402. #endif
  403. {
  404.     float *cp1 = (float *)p1;
  405.     float *cp2 = (float *)p2;
  406.  
  407.     vcmp(floatcmp);
  408. }
  409.  
  410. /* dblcmp:  t_double comparison function */
  411. #ifdef AC_PROTO
  412. static int dblcmp(const void *p1, const void *p2, size_t n)
  413. #else
  414. static int dblcmp(p1, p2, n)
  415. const void *p1;
  416. const void *p2;
  417. size_t n;
  418. #endif
  419. {
  420.     double n1 = 0;
  421.     double n2 = 0;
  422.  
  423.     memcpy(&n1, p1, sizeof(n1));
  424.     memcpy(&n2, p2, sizeof(n2));
  425.     if (n1 < n2) {
  426.         return -1;
  427.     } else if (n1 > n2) {
  428.         return 1;
  429.     }
  430.  
  431.     return 0;
  432. }
  433.  
  434. /* dblvcmp:  t_doublev comparison function */
  435. #ifdef AC_PROTO
  436. static int dblvcmp(const void *p1, const void *p2, size_t n)
  437. #else
  438. static int dblvcmp(p1, p2, n)
  439. const void *p1;
  440. const void *p2;
  441. size_t n;
  442. #endif
  443. {
  444.     double *cp1 = (double *)p1;
  445.     double *cp2 = (double *)p2;
  446.  
  447.     vcmp(dblcmp);
  448. }
  449.  
  450. /* ldblcmp:  t_ldouble comparison function */
  451. #ifdef AC_PROTO
  452. static int ldblcmp(const void *p1, const void *p2, size_t n)
  453. #else
  454. static int ldblcmp(p1, p2, n)
  455. const void *p1;
  456. const void *p2;
  457. size_t n;
  458. #endif
  459. {
  460. #ifdef AC_LDOUBLE
  461.     long double n1 = 0;
  462.     long double n2 = 0;
  463.  
  464.     memcpy(&n1, p1, sizeof(n1));
  465.     memcpy(&n2, p2, sizeof(n2));
  466.     if (n1 < n2) {
  467.         return -1;
  468.     } else if (n1 > n2) {
  469.         return 1;
  470.     }
  471.  
  472.     return 0;
  473. #else
  474.     return 0;
  475. #endif
  476. }
  477.  
  478. /* ldblvcmp:  t_ldoublev comparison function */
  479. #ifdef AC_PROTO
  480. static int ldblvcmp(const void *p1, const void *p2, size_t n)
  481. #else
  482. static int ldblvcmp(p1, p2, n)
  483. const void *p1;
  484. const void *p2;
  485. size_t n;
  486. #endif
  487. {
  488. #ifdef AC_LDOUBLE
  489.     long double *cp1 = (long double *)p1;
  490.     long double *cp2 = (long double *)p2;
  491.  
  492.     vcmp(ldblcmp);
  493. #else
  494.     return 0;
  495. #endif
  496. }
  497.  
  498. /* ptrcmp:  t_pointer comparison function */
  499. #ifdef AC_PROTO
  500. static int ptrcmp(const void *p1, const void *p2, size_t n)
  501. #else
  502. static int ptrcmp(p1, p2, n)
  503. const void *p1;
  504. const void *p2;
  505. size_t n;
  506. #endif
  507. {
  508.     void *n1 = NULL;
  509.     void *n2 = NULL;
  510.  
  511.     memcpy(&n1, p1, sizeof(n1));
  512.     memcpy(&n2, p2, sizeof(n2));
  513.     if (n1 < n2) {
  514.         return -1;
  515.     } else if (n1 > n2) {
  516.         return 1;
  517.     }
  518.  
  519.     return 0;
  520. }
  521.  
  522. /* ptrvcmp:  t_pointerv comparison function */
  523. #ifdef AC_PROTO
  524. static int ptrvcmp(const void *p1, const void *p2, size_t n)
  525. #else
  526. static int ptrvcmp(p1, p2, n)
  527. const void *p1;
  528. const void *p2;
  529. size_t n;
  530. #endif
  531. {
  532.     void **cp1 = (void **)p1;
  533.     void **cp2 = (void **)p2;
  534.  
  535.     vcmp(ptrcmp);
  536. }
  537.  
  538. /* t_string -> use standard library function strncmp */
  539.  
  540. /* cistrncmp:  t_cistring comparison function */
  541. #ifdef AC_PROTO
  542. static int cistrncmp(const char *cs1, const char *cs2, size_t n)
  543. #else
  544. static int cistrncmp(cs1, cs2, n)
  545. const char *cs1;
  546. const char *cs2;
  547. size_t n;
  548. #endif
  549. {
  550.     int i = 0;    /* loop counter */
  551.  
  552.     for (i = 0; i < n && toupper(*cs1) == toupper(*cs2); ++i, ++cs1, ++cs2) {
  553.         if (*cs1 == '\0') {
  554.             return 0;
  555.         }
  556.     }
  557.  
  558.     return toupper(*cs1) - toupper(*cs2);
  559. }
  560.  
  561. /* bincmp:  t_binary comparison function */
  562. #ifdef AC_PROTO
  563. static int bincmp(const void *p1, const void *p2, size_t n)
  564. #else
  565. static int bincmp(p1, p2, n)
  566. const void *p1;
  567. const void *p2;
  568. size_t n;
  569. #endif
  570. {
  571.     unsigned char *v1 = (unsigned char *)p1;
  572.     unsigned char *v2 = (unsigned char *)p2;
  573.  
  574.     for (; n > 0; --n, ++v1, ++v2) {
  575.         if (*v1 != *v2) {
  576.             return *v1 - *v2;
  577.         }
  578.     }
  579.  
  580.     return 0;
  581. }
  582.  
  583. /* cbase comparison function table definition */
  584. const cbcmp_t cbcmpv[] = {
  585.     charcmp,        /* t_char    =  0 */
  586.     charvcmp,        /* t_charv    =  1 */
  587.     ucharcmp,        /* t_uchar    =  2 */
  588.     ucharvcmp,        /* t_ucharv    =  3 */
  589.     shortcmp,        /* t_short    =  4 */
  590.     shortvcmp,        /* t_shortv    =  5 */
  591.     ushortcmp,        /* t_ushort    =  6 */
  592.     ushortvcmp,        /* t_ushortv    =  7 */
  593.     intcmp,            /* t_int    =  8 */
  594.     intvcmp,        /* t_intv    =  9 */
  595.     uintcmp,        /* t_uint    = 10 */
  596.     uintvcmp,        /* t_uintv    = 11 */
  597.     longcmp,        /* t_long    = 12 */
  598.     longvcmp,        /* t_longv    = 13 */
  599.     ulongcmp,        /* t_ulong    = 14 */
  600.     ulongvcmp,        /* t_ulongv    = 15 */
  601.     floatcmp,        /* t_float    = 16 */
  602.     floatvcmp,        /* t_floatv    = 17 */
  603.     dblcmp,            /* t_double    = 18 */
  604.     dblvcmp,        /* t_doublev    = 19 */
  605.     ldblcmp,        /* t_ldouble    = 20 */
  606.     ldblvcmp,        /* t_ldoublev    = 21 */
  607.     ptrcmp,            /* t_pointer    = 22 */
  608.     ptrvcmp,        /* t_pointerv    = 23 */
  609.     (cbcmp_t)strncmp,    /* t_string    = 24 */
  610.     (cbcmp_t)cistrncmp,    /* t_cistring    = 25 */
  611.     bincmp,            /* t_binary    = 26 */
  612. };
  613.